#include <iostream>
using namespace std;
//写时复制，但是代码无法判断是读还是写
////统一视为写，更浪费内存
//所以应该区分好，怎么区分呢，
//对于内置的数据类型，我们无法实现区分
//所以只能重载新的数据类型，写出赋值运算符和
//输出流运算符就可以了
class String{
    public:
        String(){}
        String(const char *pstr){}
            ~String(){
                if(--*(int *)(_pstr-4)==0){
                    delete [] (_pstr-4);
                }
            }
        String(const String& rhs)
        :_pstr(rhs._pstr)
        {
            ++(int*)(_pstr-4);
        }
        //左操作数--，右操作数++
        String & operator=(const String& rhs){
            if(this!=&rhs){
                delete [] _pstr;

                if(--*(int*)(_pstr-4)==0){
                    delete [] _pstr-4;
                }
                ++*(int*)(_pstr-4);
                return *this;
            }
            
        }
        int refcount()const(){
            return *(int*)(_pstr-4);
        }

        Obj operator[](int index){

        }
    private:
        char *_pstr;

        class Charproxy{
        public:Charproxy(int index)
                :_index(index)
               {
               }
                //赋值运算符
                char operator=(const char& c){
                    
               }
        private:
               int _index;
        };
    public:
        Charproxy operator[](int index){
            return Charproxy(index,*this);
        }

    
ostream & operator<<(ostream & os,const String::CharProxy & rhs);
};
//CHarproxy是shtring的内部类，访问一个自由的内部类

//需要设置为string的友元
ostream & operator<<(ostream & os,const String::CharProxy & rhs){

}

void test(){
    String s("hello");
    cout<<s[0]<<endl;
    s[0]='H';
}
int main(int argc, char * argv[]){
    
    return 0;
}

